package com.ciwong.epaper.widget.catalog;

import android.support.v7.widget.RecyclerView;

import com.ciwong.epaper.widget.catalog.base.BaseNode;

import java.util.ArrayList;
import java.util.List;

/**
 * date :2018/8/2
 * author: lzh
 * description: 节点处理帮助类
 * version:
 */
public class NodeHelp<E> {

    /**
     * 为添加加进来的数据 按树结构排序
     *
     * @param list     添加的数据
     * @param isExpand 是否展开存储
     * @return 返回  梳理完结构 展开或未展开的数据
     */
    public static List<BaseNode> sortNode(List<BaseNode> list, boolean isExpand) {
        if (null == list) new Throwable("list cannot be  null!");

        int size = list.size();
        BaseNode p = null;
        BaseNode c = null;
        for (int i = 0; i < size; i++) {
            p = list.get(i);
            for (int j = i + 1; j < size; j++) {
                c = list.get(j);
                if (p.isParentOf(c)) {
                    p.getChildrenList().add(c);
                    c.setParentNode(p);
                } else if (p.isChildOf(c)){
                    c.getChildrenList().add(p);
                    p.setParentNode(c);
                }
            }
        }
        /**至此结构已经梳理清楚 及父子关系清楚了，但是是否是展开下面处理*/
        /*==================================================================================*/

        return getNodeExpand(list, isExpand);
    }

    /**
     *
     * @param list 添加的数据
     * @param isExpand 是否展开
     * @return 返回 展开或未展开的数据
     */
    private static List<BaseNode> getNodeExpand(List<BaseNode> list,boolean isExpand){

        List<BaseNode> structureNodeList = new ArrayList<>();
        int size = list.size();
        BaseNode node;
        for (int i = 0; i < size; i++) {
            node = list.get(i);
            if (node.isFirstLevel()) {
                if (node.isParentNode())
                node.setExpand(false);
                structureNodeList.add(node);
            }
        }
        if (!isExpand) {//不展开存储
            list.clear();
            list = structureNodeList;
        } else {
            list.clear();
            list=expandList(structureNodeList,list);
        }
        return list;
    }

    /**
     * 递归循环展开不同层级的目录
     * @param list
     * @param listReturn
     */
    private static List<BaseNode> expandList(List<BaseNode> list, List<BaseNode> listReturn) {
        for (int i = 0; i < list.size(); i++) {
            BaseNode sNode = list.get(i);

            if (sNode.isParentNode())//如果是父节点（即是还可以展开的）
            sNode.setExpand(true);

            listReturn.add(sNode);//结构中先添加父节点
            List<BaseNode> childrenList = sNode.getChildrenList();
            if (childrenList != null&&childrenList.size()>0) {//当结构父节点中有子节点时再添加子节点
               expandList(childrenList, listReturn);
            }
        }
        return listReturn;
    }

    public static void expandOrcollapsePositionList(RecyclerView.Adapter adapter, List<BaseNode> list, int position){
        BaseNode baseNode = list.get(position);
        if (baseNode!=null&&baseNode.isParentNode()){//点击条目不为空 并且不是最后一层目录（及有子目录）
            boolean expandOld = baseNode.isExpand();
            if (expandOld){//原本是展开状态 (注意哦 需要递归收缩 因为有可能子目录中有展开的子目录)
                collapsePositionList(adapter, list, position);
            }else{//原本是收缩状态
                list.addAll(position+1,baseNode.getChildrenList());
                adapter.notifyDataSetChanged();
            }
            baseNode.setExpand(!expandOld);
        }
    }

    /**
     * 收缩目录
     * @param adapter
     * @param list
     * @param position
     */
    private static void collapsePositionList(RecyclerView.Adapter adapter, List<BaseNode> list, int position){
        BaseNode baseNode = list.get(position);
        baseNode.setExpand(false);
        List<BaseNode> childrenList = baseNode.getChildrenList();
        for (int i=0;i<childrenList.size();i++){
            if (childrenList.get(i).isExpand()) {
                collapsePositionList(adapter, list, position + 1);
            }
            //当是不可展开的就直接删除，当时可展开的把展开的部分删除完后再删除
            list.remove(position+1);
            adapter.notifyItemRemoved(position+1);
        }

    }
}
